home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_gene.lha / LEDA-3.1c-generic / incl / LEDA / Int0.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-05  |  8.3 KB  |  275 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  Int0.h
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. /*         Int.h             */
  17.  
  18. /**************************************************************************
  19.     Headerfile for Int arithmetic in C++,
  20.  
  21.     RD, IWR Uni Heidelberg, 30.11.90
  22.  
  23. 16.12.91, RD    Redesigned the class Int to enable all operations between
  24.         Int and any of char, short, int, long or these unsigned.
  25.         To convert from Int to int, unsigned int ... the
  26.         functions Iisint, Iisuint, ... and intasI, uintasI, ...
  27.         are provided. All PLACE operators were removed.
  28.  
  29. june/juli 93    some changes for LEDA by S. Meiser & S. Naeher
  30.  
  31. *****************************************************************************/
  32.  
  33.  
  34. #ifndef _INT_H
  35. #define _INT_H
  36.  
  37. #include <LEDA/basic.h>
  38. #include <LEDA/impl/iint.h>
  39.  
  40. class Int {
  41.     Integer    I;
  42. public:
  43.     Int();
  44.     Int(int);
  45.     Int(unsigned int);
  46.     Int(long);
  47.     Int(unsigned long);
  48.     Int(const Int&);
  49.     ~Int();
  50.  
  51.     Int& operator=(const Int&);
  52.     int operator=(int);
  53.     
  54.     friend BOOLEAN Iisint(const Int&);
  55.     friend BOOLEAN Iisuint(const Int&);
  56.     friend BOOLEAN Iislong(const Int&);
  57.     friend BOOLEAN Iisulong(const Int&);
  58.     friend int intasI(const Int&);
  59.     friend unsigned int uintasI(const Int&);
  60.     friend long longasI(const Int&);
  61.     friend unsigned long ulongasI(const Int&);
  62.     friend double Itodouble(const Int&);
  63.  
  64.     friend int Ilog(const Int&);
  65.  
  66.     friend Int operator+(const Int&, const Int&);
  67.     friend Int operator-(const Int&, const Int&);
  68.     Int& operator+=(const Int&);
  69.     Int& operator-=(const Int&);
  70.     Int& operator++();
  71.     Int& operator--();
  72.  
  73.     /* Ergaenzung 07.05.92 SD */
  74.     friend Int operator-(const Int&);
  75.         
  76.         void negate();
  77.  
  78.     BOOLEAN operator!();
  79.     friend BOOLEAN operator==(const Int&, const Int&);
  80.     friend BOOLEAN operator>(const Int&, const Int&);
  81.     friend BOOLEAN operator!=(const Int&, const Int&);
  82.     friend BOOLEAN operator>=(const Int&, const Int&);
  83.     friend BOOLEAN operator<(const Int&, const Int&);
  84.     friend BOOLEAN operator<=(const Int&, const Int&);
  85.     friend Int operator*(const Int&, const Int&);
  86.     Int& operator*=(const Int&);
  87.     friend Int operator>>(const Int&, unsigned int);
  88.     friend Int operator<<(const Int&, unsigned int);
  89.     Int& operator>>=(unsigned int);
  90.     Int& operator<<=(unsigned int);
  91.     friend BOOLEAN Isr1(Int&);
  92.     friend BOOLEAN Ieven(const Int&);
  93.  
  94.     friend BOOLEAN Ige0(const Int&);
  95.     friend BOOLEAN Igt0(const Int&);
  96.     friend BOOLEAN Ile0(const Int&);
  97.     friend BOOLEAN Ilt0(const Int&);
  98.     friend BOOLEAN Ieq0(const Int&);
  99.     friend BOOLEAN Ieq1(const Int&);
  100.     friend int sign(const Int&); // returns +1, 0, -1
  101.     friend Int abs(const Int&);
  102.  
  103.     friend void Idiv(Int&, Int&, const Int&, const Int&);
  104.     friend void uIdiv(Int&, Int&, const Int&, const Int&);
  105.     friend Int operator/(const Int&, const Int&);
  106.     Int& operator/=(const Int&);
  107.     friend Int operator%(const Int&, const Int&);
  108.     Int& operator%=(const Int&);
  109.  
  110.     friend int fscanI(FILE*, Int&);
  111.     friend int fprintI(FILE*, const Int&);
  112.  
  113.     friend int Itoa(const Int&, char*);
  114.     friend int atoI(char*, Int&);
  115.  
  116.     friend Int gcd(const Int&, const Int&);        // "bester gcd" 
  117.     friend Int bgcd(const Int&, const Int&);    // binaerer gcd
  118.     friend Int dgcd(const Int&, const Int&);    // naiver gcd
  119.     friend Int elba(Int&, Int&, const Int&, const Int&);
  120.     friend Int belba(Int&, Int&, const Int&, const Int&);
  121.  
  122.     friend Int random(const Int&); // Zufallsgenerator
  123.  
  124. };
  125.  
  126. inline Int::Int()            { cI(&I); }
  127. inline Int::Int(int i)            { cIasint(&I, i); }
  128. inline Int::Int(unsigned int i)        { cIasuint(&I, i); }
  129. inline Int::Int(long i)            { cIaslong(&I, i); }
  130. inline Int::Int(unsigned long i)    { cIasulong(&I, i); }
  131. inline Int::Int(const Int &a)        { cIasI(&I, &a.I); }
  132. inline Int::~Int()            { dI(&I); }
  133.  
  134. inline Int& Int::operator=(const Int &a)
  135.   { IasI(&I, &a.I); return *this; }
  136. inline int Int::operator=(int i)
  137.   { Iasint(&I, i); return i; }
  138.     
  139. inline BOOLEAN Iisint(const Int &a)
  140.   { return Iisint(&a.I); }
  141. inline BOOLEAN Iisuint(const Int &a)
  142.   { return Iisuint(&a.I); }
  143. inline BOOLEAN Iislong(const Int &a)
  144.   { return Iislong(&a.I); }
  145. inline BOOLEAN Iisulong(const Int &a)
  146.   { return Iisulong(&a.I); }
  147. inline int intasI(const Int &a)
  148.   { return intasI(&a.I); }
  149. inline unsigned int uintasI(const Int &a)
  150.   { return uintasI(&a.I); }
  151. inline long longasI(const Int &a)
  152.   { return longasI(&a.I); }
  153. inline unsigned long ulongasI(const Int &a)
  154.   { return ulongasI(&a.I); }
  155. inline double Itodouble(const Int &a)
  156.   { return Itodouble(&a.I); }
  157.  
  158. inline Int& Int::operator+=(const Int& a)
  159.   { IplasI(&I, &a.I); return *this; }
  160. inline Int& Int::operator-=(const Int &a)
  161.   { ImiasI(&I, &a.I); return *this; }
  162. inline Int& Int::operator++()
  163.   { Iinc(&I); return *this; }
  164. inline Int& Int::operator--()
  165.   { Idec(&I); return *this; }
  166.  
  167. inline Int operator-(const Int &a)
  168.   { Int b(a); Ineg(&b.I); return b; }
  169.  
  170. inline void Int::negate()
  171.   { Ineg(&I); }
  172.  
  173. inline BOOLEAN Int::operator!()
  174.   { return Ieq0(&I); }
  175. inline BOOLEAN operator==(const Int &a, const Int &b) 
  176.   { return IeqI(&a.I, &b.I); }
  177. inline BOOLEAN operator>(const Int &a, const Int &b) 
  178.   { return IgtI(&a.I, &b.I); }
  179. inline BOOLEAN operator!=(const Int &a, const Int &b) 
  180.   { return IneI(&a.I, &b.I); }
  181. inline BOOLEAN operator>=(const Int &a, const Int &b) 
  182.   { return IgeI(&a.I, &b.I); }
  183. inline BOOLEAN operator<(const Int &a, const Int &b) 
  184.   { return IltI(&a.I, &b.I); }
  185. inline BOOLEAN operator<=(const Int &a, const Int &b) 
  186.   { return IleI(&a.I, &b.I); }
  187. inline Int& Int::operator*=(const Int &a)
  188.   { ImuasI(&I, &a.I); return *this; }
  189. inline Int& Int::operator>>=(unsigned int u)
  190.   { Israsint(&I, u); return *this; }
  191. inline Int& Int::operator<<=(unsigned int u)
  192.   { Islasint(&I, u); return *this; }
  193. inline BOOLEAN Isr1(Int &a)
  194.   { return Isr1(&a.I); }
  195. inline BOOLEAN Ieven(const Int &a) 
  196.   { return Ieven(&a.I); }
  197.  
  198. inline BOOLEAN Ige0(const Int &a)
  199.   { return Ige0(&a.I); }
  200. inline BOOLEAN Igt0(const Int &a)
  201.   { return Igt0(&a.I); }
  202. inline BOOLEAN Ile0(const Int &a)
  203.   { return Ile0(&a.I); }
  204. inline BOOLEAN Ilt0(const Int &a)
  205.   { return Ilt0(&a.I); }
  206. inline BOOLEAN Ieq0(const Int &a)
  207.   { return Ieq0(&a.I); }
  208. inline BOOLEAN Ieq1(const Int &a)
  209.   { return Ieq1(&a.I); }
  210. inline int sign(const Int &a)
  211.   { return sign(&a.I); } // returns +1, 0, -1
  212. inline Int abs(const Int &a)
  213.   { if (Ige0(&a.I)) { return a; } else { return -a; } }
  214.  
  215. inline void Idiv(Int &q, Int &r, const Int &a, const Int &b)
  216.   { Idiv(&q.I, &r.I, &a.I, &b.I); }
  217. inline void uIdiv(Int &q, Int &r, const Int &a, const Int &b)
  218.   { uIdiv(&q.I, &r.I, &a.I, &b.I); }
  219. inline Int& Int::operator/=(const Int &a)
  220.   { IdiasI(&I, &a.I); return *this; }
  221. inline Int& Int::operator%=(const Int &a)
  222.   { IreasI(&I, &a.I); return *this; }
  223.  
  224. inline int Ilog(const Int &a)    
  225.     { return Ilog(&a.I); }
  226.     
  227. inline Int operator+(const Int &a, const Int &b)
  228.     { Int c; IasIplI(&c.I, &a.I, &b.I); return c; }
  229. inline Int operator-(const Int &a, const Int &b)
  230.     { Int c; IasImiI(&c.I, &a.I, &b.I); return c; }
  231.  
  232. inline Int operator*(const Int &a, const Int &b)
  233.     { Int c; IasImuI(&c.I, &a.I, &b.I); return c; }
  234.  
  235. inline Int operator>>(const Int &a, unsigned int u)
  236.     { Int c; IasIsrint(&c.I, &a.I, u); return c; }
  237. inline Int operator<<(const Int &a, unsigned int u)
  238.     { Int c; IasIslint(&c.I, &a.I, u); return c; }
  239.  
  240. inline Int operator/(const Int &a, const Int &b)
  241.     { Int c; IasIdiI(&c.I, &a.I, &b.I); return c; }
  242. inline Int operator%(const Int &a, const Int &b)
  243.     { Int c; IasIreI(&c.I, &a.I, &b.I); return c; }
  244.  
  245. inline int fscanI(FILE * f, Int &a)
  246.     { return fscanI(f, &a.I); }
  247. inline int fprintI(FILE * f, const Int &a)
  248.     { return fprintI(f, &a.I); }
  249.  
  250. inline int Itoa(const Int &a, char s[])
  251.     { return Itoa(&a.I, s); }
  252. inline int atoI(char s[], Int &a)
  253.     { return atoI(s, &a.I); }
  254.  
  255. inline Int gcd(const Int &a, const Int &b)
  256.     { Int d; Igcd(&d.I, &a.I, &b.I); return d; }
  257. inline Int bgcd(const Int &a, const Int &b)
  258.     { Int d; Ibgcd(&d.I, &a.I, &b.I); return d; }
  259. inline Int dgcd(const Int &a, const Int &b)
  260.     { Int d; Idgcd(&d.I, &a.I, &b.I); return d; }
  261. inline Int elba(Int &u, Int &v, const Int &a, const Int &b)
  262.     { Int d; Ielba(&d.I, &u.I, &v.I, &a.I, &b.I); return d; }
  263. inline Int belba(Int &u, Int &v, const Int &a, const Int &b)
  264.     { Int d; Ibelba(&d.I, &u.I, &v.I, &a.I, &b.I); return d; }
  265.  
  266. inline Int random(const Int &b)
  267.     { Int a; IasrandomI(&a.I, &b.I); return a; }
  268.         
  269. ostream& operator<<(ostream &out, const Int &a);
  270. istream& operator>>(istream &in, Int &a);
  271.  
  272. const IN_INT_BUF_LENGTH=10000;
  273.  
  274. #endif
  275.